home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format CD 42 / Amiga Format AFCD42 (Issue 126, Aug 1999).iso / -serious- / programming / other / jikes / src / double.cpp < prev    next >
C/C++ Source or Header  |  1999-05-14  |  7KB  |  362 lines
  1. // $Id: double.cpp,v 1.4 1999/02/17 19:06:06 shields Exp $
  2. //
  3. // This software is subject to the terms of the IBM Jikes Compiler
  4. // License Agreement available at the following URL:
  5. // http://www.ibm.com/research/jikes.
  6. // Copyright (C) 1996, 1998, International Business Machines Corporation
  7. // and others.  All Rights Reserved.
  8. // You must accept the terms of that agreement to use this software.
  9. //
  10. #include "config.h"
  11. #include <iostream.h>
  12. #include "double.h"
  13. #include "long.h"
  14. IEEEfloat::IEEEfloat(float d)
  15. {
  16.     FloatValue() = d;
  17. }
  18.  
  19. IEEEfloat::IEEEfloat(u4 a)
  20. {
  21.     Word() = a;
  22. }
  23.  
  24. IEEEfloat::IEEEfloat(i4 a)
  25. {
  26.     FloatValue() = a;
  27. }
  28.  
  29. IEEEfloat::IEEEfloat(char * name)
  30. {
  31.     FloatValue() = atof(name);
  32. }
  33.  
  34. int IEEEfloat::IntValue()
  35. {
  36.     return (int) FloatValue();
  37. }
  38. int IEEEfloat::LongValue()
  39. {
  40.     return (long) FloatValue();
  41. }
  42.  
  43. IEEEdouble IEEEdouble::min_long = IEEEdouble(0xc3e00000, 0x00000000);
  44.  
  45. IEEEdouble::IEEEdouble(double d)
  46. {
  47.     DoubleValue() = d;
  48. }
  49.  
  50. IEEEdouble::IEEEdouble(u4 a, u4 b)
  51. {
  52.     HighWord() = a;
  53.     LowWord() = b;
  54. }
  55.  
  56. IEEEdouble::IEEEdouble(IEEEfloat a)
  57. {
  58.     DoubleValue() = a.FloatValue();
  59. }
  60.  
  61. IEEEdouble::IEEEdouble(i4 a)
  62. {
  63.     DoubleValue() = a;
  64. }
  65.  
  66.  
  67. IEEEdouble::IEEEdouble(u4 a)
  68. {
  69.     HighWord() = 0;
  70.     LowWord() = a;
  71. }
  72.  
  73. IEEEdouble::IEEEdouble(char * name)
  74. {
  75.     DoubleValue()  = atof(name);
  76. }
  77.  
  78. bool IEEEdouble::operator== (IEEEdouble op)
  79. {
  80.     return DoubleValue() == op.DoubleValue();
  81. }
  82.  
  83. bool IEEEdouble::operator!= (IEEEdouble op)
  84. {
  85.     return DoubleValue() != op.DoubleValue();
  86. }
  87.  
  88. IEEEdouble IEEEdouble::operator+ (IEEEdouble op)
  89. {
  90.     return IEEEdouble(DoubleValue() + op.DoubleValue());
  91. }
  92.  
  93. IEEEdouble& IEEEdouble::operator+= (IEEEdouble op)
  94. {
  95.     *this = *this + op;
  96.     return *this;
  97. }
  98.  
  99. IEEEdouble IEEEdouble::operator- ()
  100. {
  101.     return IEEEdouble(- this -> DoubleValue());
  102. }
  103.  
  104. IEEEdouble IEEEdouble::operator- (IEEEdouble op)
  105. {
  106.     return IEEEdouble(DoubleValue() + (-op.DoubleValue()));
  107. }
  108.  
  109. IEEEdouble& IEEEdouble::operator-= (IEEEdouble op)
  110. {
  111.     *this = *this - op;
  112.     return *this;
  113. }
  114.  
  115.  
  116. IEEEdouble IEEEdouble::operator* (IEEEdouble op)
  117. {
  118.     return IEEEdouble(DoubleValue() * op.DoubleValue());
  119. }
  120.  
  121. IEEEdouble& IEEEdouble::operator*= (IEEEdouble op)
  122. {
  123.     *this = *this * op;
  124.     return *this;
  125. }
  126.  
  127. IEEEdouble IEEEdouble::operator/ (IEEEdouble op)
  128. {
  129. #ifndef IEEE_DIV_0
  130.     return IEEEdouble(DoubleValue() / op.DoubleValue());
  131. #else /* IEEE_DIV_0 */
  132.     if (op.DoubleValue() == 0.0)
  133.     {
  134.     if (DoubleValue() < 0.0)
  135.         return NEGATIVE_INFINITY();
  136.     else if (DoubleValue() == 0.0)
  137.         return NaN();
  138.     else
  139.         return POSITIVE_INFINITY();
  140.     }
  141.     else
  142.     return IEEEdouble(DoubleValue() / op.DoubleValue());
  143. #endif /* IEEE_DIV_0 */
  144. }
  145.  
  146. IEEEdouble& IEEEdouble::operator/= (IEEEdouble op)
  147. {
  148. #ifndef IEEE_DIV_0
  149.     *this = *this / op;
  150. #else /* IEEE_DIV_0 */
  151.     if (op.DoubleValue() == 0.0)
  152.     {
  153.     if (*this < 0.0)
  154.         *this = NEGATIVE_INFINITY();
  155.     else if (*this == 0.0)
  156.         *this = NaN();
  157.     else
  158.         *this = POSITIVE_INFINITY();
  159.     }
  160.     else
  161.     *this = *this / op;
  162. #endif /* IEEE_DIV_0 */
  163.     return *this;
  164. }
  165.  
  166. bool IEEEdouble::operator< (IEEEdouble op)
  167. {
  168.     return (DoubleValue() < op.DoubleValue() ? 1 : 0);
  169. }
  170.  
  171. bool IEEEdouble::operator<= (IEEEdouble op)
  172. {
  173.     return (DoubleValue() <= op.DoubleValue() ? 1 : 0);
  174. }
  175.  
  176. bool IEEEdouble::operator> (IEEEdouble op)
  177. {
  178.     return (DoubleValue() > op.DoubleValue() ? 1 : 0);
  179. }
  180.  
  181. bool IEEEdouble::operator>= (IEEEdouble op)
  182. {
  183.     return (DoubleValue() >= op.DoubleValue() ? 1 : 0);
  184. }
  185.  
  186. bool IEEEfloat::operator== (IEEEfloat op)
  187. {
  188.     return FloatValue() == op.FloatValue();
  189. }
  190.  
  191. bool IEEEfloat::operator!= (IEEEfloat op)
  192. {
  193.     return FloatValue() != op.FloatValue();
  194. }
  195.  
  196.  
  197. bool IEEEfloat::operator< (IEEEfloat op)
  198. {
  199.     return (FloatValue() < op.FloatValue() ? 1 : 0);
  200. }
  201.  
  202. bool IEEEfloat::operator<= (IEEEfloat op)
  203. {
  204.     return (FloatValue() <= op.FloatValue() ? 1 : 0);
  205. }
  206.  
  207. bool IEEEfloat::operator> (IEEEfloat op)
  208. {
  209.     return (FloatValue() > op.FloatValue() ? 1 : 0);
  210. }
  211.  
  212. bool IEEEfloat::operator>= (IEEEfloat op)
  213. {
  214.     return (FloatValue() >= op.FloatValue() ? 1 : 0);
  215. }
  216.  
  217.  
  218. IEEEfloat IEEEfloat::operator+ (IEEEfloat op)
  219. {
  220.     return IEEEfloat(FloatValue() + op.FloatValue());
  221. }
  222.  
  223. IEEEfloat& IEEEfloat::operator+= (IEEEfloat op)
  224. {
  225.     *this = *this + op;
  226.     return *this;
  227. }
  228.  
  229.  
  230. IEEEfloat IEEEfloat::operator- ()
  231. {
  232.     return IEEEfloat( - this -> FloatValue());
  233.  
  234. }
  235.  
  236. IEEEfloat IEEEfloat::operator- (IEEEfloat op)
  237. {
  238.     return *this + (-op);
  239. }
  240.  
  241. IEEEfloat& IEEEfloat::operator-= (IEEEfloat op)
  242. {
  243.     *this = *this - op;
  244.     return *this;
  245. }
  246.  
  247. IEEEfloat IEEEfloat::operator* (IEEEfloat op)
  248. {
  249.     return IEEEfloat(FloatValue() * op.FloatValue());
  250. }
  251.  
  252. IEEEfloat& IEEEfloat::operator*= (IEEEfloat op)
  253. {
  254.     *this = *this * op;
  255.     return *this;
  256. }
  257.  
  258. IEEEfloat IEEEfloat::operator/ (IEEEfloat op)
  259. {
  260. #ifndef IEEE_DIV_0
  261.     return IEEEfloat(FloatValue() / op.FloatValue());
  262. #else /* IEEE_DIV_0 */
  263.     if (op.FloatValue() == 0.0)
  264.     {
  265.     if (FloatValue() < 0.0)
  266.         return IEEEfloat(IEEEdouble::NEGATIVE_INFINITY());
  267.     else if (FloatValue() == 0.0)
  268.         return IEEEfloat(IEEEdouble::NaN());
  269.     else
  270.         return IEEEfloat(IEEEdouble::POSITIVE_INFINITY());
  271.     }
  272.     else
  273.     return IEEEfloat(FloatValue() / op.FloatValue());
  274. #endif /* IEEE_DIV_0 */
  275. }
  276.  
  277. IEEEfloat& IEEEfloat::operator/= (IEEEfloat op)
  278. {
  279. #ifndef IEEE_DIV_0
  280.     *this = *this / op;
  281. #else /* IEEE_DIV_0 */
  282.     if (op.FloatValue() == 0.0)
  283.     {
  284.     if (*this < (float)0.0)
  285.         *this = IEEEdouble::NEGATIVE_INFINITY();
  286.     else if (*this == (float)0.0)
  287.         *this = IEEEdouble::NaN();
  288.     else
  289.         *this = IEEEdouble::POSITIVE_INFINITY();
  290.     }
  291.     else
  292.     *this = *this / op;
  293. #endif /* IEEE_DIV_0 */
  294.     return *this;
  295. }
  296.  
  297.  
  298. void IEEEdouble::Fmodulus(IEEEdouble a, IEEEdouble b, IEEEdouble& result)
  299. {
  300. #ifndef IEEE_DIV_0
  301.      result.DoubleValue() = fmod(a.DoubleValue(), b.DoubleValue());
  302. #else /* IEEE_DIV_0 */
  303.     if (b.DoubleValue() == 0)
  304.     result.DoubleValue() = NaN().DoubleValue();
  305.     else
  306.     result.DoubleValue() = fmod(a.DoubleValue(), b.DoubleValue());
  307. #endif /* IEEE_DIV_0 */
  308. }
  309.  
  310. void IEEEdouble::Divide(IEEEdouble dividend, IEEEdouble divisor, IEEEdouble "ient)
  311. {
  312. #ifndef IEEE_DIV_0
  313.     quotient = dividend.DoubleValue() / divisor.DoubleValue();
  314. #else /* IEEE_DIV_0 */
  315.     if (divisor.DoubleValue() == 0)
  316.     {
  317.     if (dividend.DoubleValue() < 0.0)
  318.         quotient = NEGATIVE_INFINITY();
  319.     else if (dividend.DoubleValue() == 0.0)
  320.         quotient = NaN();
  321.     else
  322.         quotient = POSITIVE_INFINITY();
  323.     }
  324.     else
  325.     quotient = dividend.DoubleValue() / divisor.DoubleValue();
  326. #endif /* IEEE_DIV_0 */
  327.     return;
  328. }
  329.  
  330. IEEEfloat::IEEEfloat(IEEEdouble a)
  331. {
  332.     FloatValue() = a.DoubleValue();
  333. }
  334.  
  335. IEEEdouble::IEEEdouble(LongInt& a)
  336. {
  337.     DoubleValue() = a.Double();
  338. }
  339.  
  340. void IEEEfloat::Fmodulus(IEEEfloat a, IEEEfloat b, IEEEfloat& result)
  341. {
  342. #ifndef IEEE_DIV_0
  343.     result.FloatValue() = (float) fmod((double) a.FloatValue(), (double) b.FloatValue());
  344. #else /* IEEE_DIV_0 */
  345.     if (b.FloatValue() == 0.0)
  346.     result.FloatValue() = (IEEEdouble::NaN()).DoubleValue();
  347.     else
  348.     result.FloatValue() = fmod((double) a.FloatValue(), (double) b.FloatValue());
  349. #endif /* IEEE_DIV_0 */
  350. }
  351.  
  352. void IEEEfloat::String(char * str)
  353. {
  354.     // format value into character string
  355.     sprintf(str, "%E", FloatValue());
  356. }
  357. void IEEEdouble::String(char * str)
  358. {
  359.     // format value into character string
  360.     sprintf(str, "%E", DoubleValue());
  361. }
  362.